// my_car.cpp
#include "my_car.h"
#include "ui_my_car.h"
#include "hong.h"        // 资源文件头文件，包含图片路径定义
#include <QDebug>        // 调试输出
#include <QJsonDocument> // JSON文档处理
#include <QJsonObject>   // JSON对象处理
#include <QTimer>        // 定时器

// 构造函数
My_Car::My_Car(QWidget *parent) :
    QWidget(parent),
    ui(new Ui::My_Car),
    isConnected(false),          // 初始未连接
    headlightState(false),       // 大灯初始关闭
    warningLightState(false),    // 警示灯初始关闭
    unlockState(0),              // 初始解锁状态为0（关闭）
    lockState(1),                // 初始上锁状态为1（开启）
    ventilationState(false),     // 通风初始关闭
    engineOn(0),                 // 发动机初始停止
    detectionOn(0),              // 检测初始无人
    airTemp(25.0),               // 空调初始温度25度
    mileage(0),                  // 初始里程0
    overlayLabel(nullptr)        // 覆盖层指针初始为空
{
    ui->setupUi(this);  // 设置UI界面
    this->setStyleSheet("background: transparent;");  // 设置透明背景

    // 初始化按钮状态和样式
    updateButtonStyles();  // 更新按钮样式
    createOverlay();       // 创建覆盖层
    updateDisconnectedState();  // 更新未连接状态

    // 连接按钮点击信号到对应的槽函数
    connect(ui->Headlight_PushBUtton, &QPushButton::clicked, this, &My_Car::onHeadlightClicked);
    connect(ui->Warning_Light_PushButton, &QPushButton::clicked, this, &My_Car::onWarningLightClicked);
    connect(ui->Unlock_PushButton, &QPushButton::clicked, this, &My_Car::onUnlockClicked);
    connect(ui->Locked_PushButton, &QPushButton::clicked, this, &My_Car::onLockedClicked);
    connect(ui->Ventilation_PushButton, &QPushButton::clicked, this, &My_Car::onVentilationClicked);
    connect(ui->Reduce_PushButton, &QPushButton::clicked, this, &My_Car::onReduceClicked);
    connect(ui->Add_PushButton, &QPushButton::clicked, this, &My_Car::onAddClicked);
}

// 析构函数
My_Car::~My_Car()
{
    destroyOverlay();  // 销毁覆盖层
    delete ui;         // 删除UI界面
}

// 更新按钮样式函数
void My_Car::updateButtonStyles()
{
    qDebug() << "[My_Car]: 更新按钮样式 - 解锁:" << unlockState << "上锁:" << lockState
             << "发动机:" << engineOn << "检测:" << detectionOn << "里程:" << mileage;

    // 解锁按钮：状态为0显示JIESUO0，为1显示JIESUO1
    QString unlockStyle = unlockState ?
        QString("border-image: url(%1);").arg(JIESUO1) :  // 解锁状态图片
        QString("border-image: url(%1);").arg(JIESUO0);   // 未解锁状态图片
    ui->Unlock_PushButton->setStyleSheet(unlockStyle);

    // 上锁按钮：状态为0显示SHANGSUO0，为1显示SHANGSUO1
    QString lockStyle = lockState ?
        QString("border-image: url(%1);").arg(SHANGSUO1) :  // 上锁状态图片
        QString("border-image: url(%1);").arg(SHANGSUO0);   // 未上锁状态图片
    ui->Locked_PushButton->setStyleSheet(lockStyle);

    // 发动机状态：状态为0显示TINGZHI，为1显示ZHENGCHANG
    QString engineStyle = engineOn ?
        QString("border-image: url(%1);").arg(ZHENGCHANG) :  // 发动机正常图片
        QString("border-image: url(%1);").arg(TINGZHI);      // 发动机停止图片
    ui->Engine_Label->setStyleSheet(engineStyle);

    // 人员检测状态：状态为0显示WUREN，为1显示YOUREN
    QString detectionStyle = detectionOn ?
        QString("border-image: url(%1);").arg(YOUREN) :  // 有人状态图片
        QString("border-image: url(%1);").arg(WUREN);    // 无人状态图片
    ui->Detection_Label->setStyleSheet(detectionStyle);

    // 里程显示：显示数值0-250
    ui->Mileage_Label_2->setText(QString("%1 km").arg(mileage));  // 设置里程文本
    ui->Mileage_Label_2->setStyleSheet("color: white; font-size: 24px;");  // 设置文本样式

    // 其他按钮样式保持不变
    ui->Headlight_PushBUtton->setStyleSheet(headlightState ?
        QString("border-image: url(%1);").arg(LIANGDENG) :    // 大灯亮起图片
        QString("border-image: url(%1);").arg(MIEDENG));      // 大灯熄灭图片

    ui->Warning_Light_PushButton->setStyleSheet(warningLightState ?
        QString("border-image: url(%1);").arg(SHUANGSHANLIANG) :  // 双闪灯亮起图片
        QString("border-image: url(%1);").arg(SHUANGSHANMIE));    // 双闪灯熄灭图片

    ui->Ventilation_PushButton->setStyleSheet(ventilationState ?
        QString("border-image: url(%1);").arg(TONGFENG1) :  // 通风开启图片
        QString("border-image: url(%1);").arg(TONGFENG0));  // 通风关闭图片

    ui->air_conditioning_lcdNumber->display(airTemp);  // 显示空调温度
}

// 数据接收槽函数（处理MQTT消息）
void My_Car::dataUpSlot(const QByteArray &msg)
{
    if (!isConnected) {
        setConnectedState(true);  // 如果未连接，设置为已连接状态
    }

    qDebug() << "[My_Car]: 收到MQTT消息:" << msg;
    QJsonDocument doc = QJsonDocument::fromJson(msg);  // 解析JSON数据
    if(!doc.isObject()) {
        qDebug() << "[My_Car]: JSON解析失败";
        return;
    }

    QJsonObject obj = doc.object();  // 获取JSON对象
    bool needUpdate = false;         // 标记是否需要更新界面

    // 处理解锁状态 key1_up
    if(obj.contains("key1_up")) {
        int receivedState = obj["key1_up"].toInt();  // 获取解锁状态值
        if (receivedState >= 0 && receivedState <= 1 && receivedState != unlockState) {
            unlockState = receivedState;
            // 互斥逻辑：解锁为1时，上锁必须为0
            if (unlockState == 1) {
                lockState = 0;
            }
            needUpdate = true;
            qDebug() << "[My_Car]: 解锁状态更新为:" << unlockState;
        }
    }

    // 处理上锁状态 key2_up
    if(obj.contains("key2_up")) {
        int receivedState = obj["key2_up"].toInt();  // 获取上锁状态值
        if (receivedState >= 0 && receivedState <= 1 && receivedState != lockState) {
            lockState = receivedState;
            // 互斥逻辑：上锁为1时，解锁必须为0
            if (lockState == 1) {
                unlockState = 0;
            }
            needUpdate = true;
            qDebug() << "[My_Car]: 上锁状态更新为:" << lockState;
        }
    }

    // 处理里程信息 key3_up
    if(obj.contains("key3_up")) {
        int receivedMileage = obj["key3_up"].toInt();  // 获取里程值
        if (receivedMileage >= 0 && receivedMileage <= 250 && receivedMileage != mileage) {
            mileage = receivedMileage;
            needUpdate = true;
            qDebug() << "[My_Car]: 里程更新为:" << mileage;
        }
    }

    // 处理发动机状态（假设字段为motor_up）
    if(obj.contains("motor_up")) {
        int receivedState = obj["motor_up"].toInt();  // 获取发动机状态
        if (receivedState >= 0 && receivedState <= 1 && receivedState != engineOn) {
            engineOn = receivedState;
            needUpdate = true;
            qDebug() << "[My_Car]: 发动机状态更新为:" << engineOn;
        }
    }

    // 处理人员检测状态（假设字段为gd_jug_up）
    if(obj.contains("gd_jug_up")) {
        int receivedState = obj["gd_jug_up"].toInt();  // 获取人员检测状态
        if (receivedState >= 0 && receivedState <= 1 && receivedState != detectionOn) {
            detectionOn = receivedState;
            needUpdate = true;
            qDebug() << "[My_Car]: 人员检测状态更新为:" << detectionOn;
        }
    }

    // 处理其他状态字段（大灯、双闪灯、通风、空调温度等）
    if(obj.contains("led1_up")) {
        bool receivedState = obj["led1_up"].toInt() == 1;  // 获取大灯状态
        if (receivedState != headlightState) {
            headlightState = receivedState;
            needUpdate = true;
            qDebug() << "[My_Car]: 大灯状态更新为:" << receivedState;
        }
    }

    if(obj.contains("led3_up")) {
        bool receivedState = obj["led3_up"].toInt() == 1;  // 获取双闪灯状态
        if (receivedState != warningLightState) {
            warningLightState = receivedState;
            needUpdate = true;
            qDebug() << "[My_Car]: 双闪灯状态更新为:" << receivedState;
        }
    }

    if(obj.contains("fan_up")) {
        bool receivedState = obj["fan_up"].toInt() == 1;  // 获取通风状态
        if (receivedState != ventilationState) {
            ventilationState = receivedState;
            needUpdate = true;
            qDebug() << "[My_Car]: 通风状态更新为:" << receivedState;
        }
    }

    if(obj.contains("air_up")) {
        double receivedTemp = obj["air_up"].toDouble();  // 获取空调温度
        if (receivedTemp >= 15 && receivedTemp <= 30 && receivedTemp != airTemp) {
            airTemp = receivedTemp;
            needUpdate = true;
            qDebug() << "[My_Car]: 空调温度更新为:" << airTemp;
        }
    }

    // 如果有状态变化，更新界面
    if (needUpdate) {
        updateButtonStyles();        // 更新按钮样式
        updateButtonsAvailability(); // 更新按钮可用性
        qDebug() << "[My_Car]: 界面状态已更新";
    } else {
        qDebug() << "[My_Car]: 无状态变化，无需更新界面";
    }
}

// 解锁按钮点击处理
void My_Car::onUnlockClicked()
{
    if (!isConnected) return;  // 未连接时直接返回

    // 检查是否可以改变状态
    if (!canChangeLockUnlockState()) {
        qDebug() << "[My_Car]: 当前状态不允许解锁操作";
        return;
    }

    // 更新状态：解锁为1，上锁为0
    unlockState = 1;
    lockState = 0;

    updateButtonStyles();        // 更新按钮样式
    updateButtonsAvailability(); // 更新按钮可用性
    sendUnlockCommand();         // 发送解锁命令
    qDebug() << "[My_Car]: 发送解锁命令，状态: 解锁=" << unlockState << "上锁=" << lockState;
}

// 上锁按钮点击处理
void My_Car::onLockedClicked()
{
    if (!isConnected) return;  // 未连接时直接返回

    // 检查是否可以改变状态
    if (!canChangeLockUnlockState()) {
        qDebug() << "[My_Car]: 当前状态不允许上锁操作";
        return;
    }

    // 更新状态：上锁为1，解锁为0
    lockState = 1;
    unlockState = 0;

    updateButtonStyles();        // 更新按钮样式
    updateButtonsAvailability(); // 更新按钮可用性
    sendLockCommand();           // 发送上锁命令
    qDebug() << "[My_Car]: 发送上锁命令，状态: 解锁=" << unlockState << "上锁=" << lockState;
}

// 检查是否可以改变锁状态
bool My_Car::canChangeLockUnlockState()
{
    // 发动机启动时，不能改变锁状态
    if (engineOn == 1) {
        qDebug() << "[My_Car]: 发动机启动，禁止改变锁状态";
        return false;
    }

    // 检测到有人时，不能改变锁状态
    if (detectionOn == 1) {
        qDebug() << "[My_Car]: 检测到有人，禁止改变锁状态";
        return false;
    }

    return true;
}

// 更新未连接状态
void My_Car::updateDisconnectedState()
{
    // MQTT未连接时：解锁按钮状态为1，上锁按钮状态为0
    headlightState = false;
    warningLightState = false;
    unlockState = 1;    // MQTT未连接时解锁状态为1
    lockState = 0;      // MQTT未连接时上锁状态为0
    ventilationState = false;
    engineOn = 0;       // 发动机停止
    detectionOn = 0;    // 检测无人
    airTemp = 25.0;     // 空调温度25度
    mileage = 0;        // 里程为0

    updateButtonStyles();  // 更新按钮样式

    if (overlayLabel) {
        overlayLabel->setVisible(true);  // 显示覆盖层
        overlayLabel->raise();           // 提升到最上层
    }

    // 禁用所有按钮
    ui->Headlight_PushBUtton->setEnabled(false);
    ui->Warning_Light_PushButton->setEnabled(false);
    ui->Unlock_PushButton->setEnabled(false);
    ui->Locked_PushButton->setEnabled(false);
    ui->Ventilation_PushButton->setEnabled(false);
    ui->Reduce_PushButton->setEnabled(false);
    ui->Add_PushButton->setEnabled(false);
}

// 更新按钮可用性
void My_Car::updateButtonsAvailability()
{
    // 根据发动机和检测状态更新按钮可用性
    bool canOperate = canChangeLockUnlockState();

    ui->Unlock_PushButton->setEnabled(canOperate && isConnected);
    ui->Locked_PushButton->setEnabled(canOperate && isConnected);

    // 设置禁用状态的透明度
    QString disabledStyle = "opacity: 0.5;";   // 禁用时半透明
    QString enabledStyle = "opacity: 1.0;";    // 启用时不透明

    ui->Unlock_PushButton->setStyleSheet(ui->Unlock_PushButton->styleSheet() +
                                        (ui->Unlock_PushButton->isEnabled() ? enabledStyle : disabledStyle));
    ui->Locked_PushButton->setStyleSheet(ui->Locked_PushButton->styleSheet() +
                                        (ui->Locked_PushButton->isEnabled() ? enabledStyle : disabledStyle));
}

// 发送控制命令
void My_Car::sendControlCommand(const QJsonObject& command)
{
    if (!GlobalVal::mqtt || !isConnected) return;  // 检查MQTT对象和连接状态

    QJsonDocument doc(command);
    QByteArray json = doc.toJson();  // 将JSON对象转换为字节数组

    QMQTT::Message mqttMessage;
    mqttMessage.setTopic("MQTT  rec");  // 设置MQTT主题
    mqttMessage.setPayload(json);      // 设置消息负载

    GlobalVal::mqtt->publish(mqttMessage);  // 发布消息
    qDebug() << "发送控制命令:" << QString(json);
}

// 大灯按钮点击槽函数
void My_Car::onHeadlightClicked()
{
    if (!isConnected) return;

    headlightState = !headlightState;  // 切换大灯状态
    updateButtonStyles();              // 更新样式
    sendHeadlightCommand(headlightState);  // 发送控制命令
    qDebug() << "[My_Car]: 大灯状态切换为:" << headlightState;
}

// 双闪按钮点击槽函数
void My_Car::onWarningLightClicked()
{
    if (!isConnected) return;

    warningLightState = !warningLightState;  // 切换双闪灯状态
    updateButtonStyles();                    // 更新样式
    sendWarningLightCommand(warningLightState);  // 发送控制命令
    qDebug() << "[My_Car]: 双闪灯状态切换为:" << warningLightState;
}

// 通风按钮点击槽函数
void My_Car::onVentilationClicked()
{
    if (!isConnected) return;

    ventilationState = !ventilationState;  // 切换通风状态
    updateButtonStyles();                  // 更新样式
    sendVentilationCommand(ventilationState);  // 发送控制命令
    qDebug() << "[My_Car]: 通风状态切换为:" << ventilationState;
}

// 温度减按钮点击槽函数
void My_Car::onReduceClicked()
{
    if (!isConnected) return;

    if (airTemp > 15) {  // 温度不低于15度
        airTemp--;       // 温度减1
        updateButtonStyles();  // 更新样式
        sendAirConditioningCommand(airTemp);  // 发送温度命令
        qDebug() << "[My_Car]: 空调温度减少到:" << airTemp;
    }
}

// 温度加按钮点击槽函数
void My_Car::onAddClicked()
{
    if (!isConnected) return;

    if (airTemp < 30) {  // 温度不高于30度
        airTemp++;       // 温度加1
        updateButtonStyles();  // 更新样式
        sendAirConditioningCommand(airTemp);  // 发送温度命令
        qDebug() << "[My_Car]: 空调温度增加到:" << airTemp;
    }
}

// 发送大灯控制命令
void My_Car::sendHeadlightCommand(bool state)
{
    QJsonObject command;
    command["led1_down"] = state ? 1 : 0;  // 设置大灯状态
    sendControlCommand(command);
}

// 发送双闪灯控制命令
void My_Car::sendWarningLightCommand(bool state)
{
    QJsonObject command;
    command["led3_down"] = state ? 1 : 0;  // 设置双闪灯状态
    sendControlCommand(command);
}

// 发送解锁命令
void My_Car::sendUnlockCommand()
{
    QJsonObject command;
    command["key1_down"] = 1;  // 设置解锁命令
    sendControlCommand(command);
}

// 发送上锁命令
void My_Car::sendLockCommand()
{
    QJsonObject command;
    command["key2_down"] = 1;  // 设置上锁命令
    sendControlCommand(command);
}

// 发送通风命令
void My_Car::sendVentilationCommand(bool state)
{
    QJsonObject command;
    command["fan_down"] = state ? 1 : 0;  // 设置通风状态
    sendControlCommand(command);
}

// 发送空调温度命令
void My_Car::sendAirConditioningCommand(double temperature)
{
    QJsonObject command;
    command["air_down"] = temperature;  // 设置空调温度
    sendControlCommand(command);
}

// 创建覆盖层（用于显示未连接提示）
void My_Car::createOverlay()
{
    if (overlayLabel) destroyOverlay();  // 如果已存在，先销毁

    overlayLabel = new QLabel(this);  // 创建新的标签
    overlayLabel->setGeometry(0, 0, this->width(), this->height());  // 设置覆盖整个窗口
    overlayLabel->setStyleSheet("background-color: rgba(128, 128, 128, 150); color: red; font-size: 70px; font-weight: bold;");  // 设置样式
    overlayLabel->setAlignment(Qt::AlignCenter);  // 居中对齐
    overlayLabel->setText("设备未连接");  // 设置提示文本
    overlayLabel->setVisible(true);  // 设置为可见
    overlayLabel->raise();  // 提升到最上层
}

// 销毁覆盖层
void My_Car::destroyOverlay()
{
    if (overlayLabel) {
        overlayLabel->setVisible(false);  // 隐藏覆盖层
        overlayLabel->deleteLater();      // 延迟删除
        overlayLabel = nullptr;           // 指针置空
    }
}

// 窗口大小改变事件处理
void My_Car::resizeEvent(QResizeEvent *event)
{
    QWidget::resizeEvent(event);  // 调用父类处理
    if (overlayLabel) {
        overlayLabel->setGeometry(0, 0, this->width(), this->height());  // 调整覆盖层大小
        overlayLabel->raise();  // 重新提升到最上层
    }
}

// 设置连接状态
void My_Car::setConnectedState(bool connected)
{
    isConnected = connected;
    qDebug() << "[My_Car]: 设置连接状态:" << connected;

    if (connected) {
        destroyOverlay();  // 连接时销毁覆盖层
        updateButtonsAvailability();  // 更新按钮可用性
        // 启用所有功能按钮
        ui->Headlight_PushBUtton->setEnabled(true);
        ui->Warning_Light_PushButton->setEnabled(true);
        ui->Ventilation_PushButton->setEnabled(true);
        ui->Reduce_PushButton->setEnabled(true);
        ui->Add_PushButton->setEnabled(true);
    } else {
        if (!overlayLabel) createOverlay();  // 未连接时创建覆盖层
        updateDisconnectedState();  // 更新未连接状态
    }
}


